#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>
#include <bitset>
#include <unordered_map>
#include <unordered_set>
#include <numeric>
#include <functional>
#include <limits>
#include <iomanip>

using namespace std;

const double PI = 3.1415926;

struct Point {
    double x, y;
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N;
    cin >> N;

    double xa, ya, xb, yb;
    cin >> xa >> ya >> xb >> yb;

    vector<Point> pts(N);
    for (int i = 0; i < N; i++) {
        cin >> pts[i].x >> pts[i].y;
    }

    // 矩形面积
    double rect_area = fabs(xa - xb) * fabs(ya - yb);

    vector<int> order(N);
    iota(order.begin(), order.end(), 0);

    double best_used_area = 0.0;

    do {
        vector<double> radii(N, 0.0); // 每个点扩散的半径
        double used_area = 0.0;

        vector<int> placed; // 已经滴下的索引

        for (int idx : order) {
            Point p = pts[idx];

            // 先考虑边界
            double r = min({fabs(p.x - xa), fabs(p.x - xb),
                            fabs(p.y - ya), fabs(p.y - yb)});

            // 再考虑已有圆
            for (int j : placed) {
                double dx = p.x - pts[j].x;
                double dy = p.y - pts[j].y;
                double d = sqrt(dx * dx + dy * dy);
                r = min(r, d - radii[j]);
            }

            if (r < 0) r = 0; // 万一负数，说明被完全覆盖

            radii[idx] = r;
            used_area += PI * r * r;
            placed.push_back(idx);
        }

        best_used_area = max(best_used_area, used_area);

    } while (next_permutation(order.begin(), order.end()));

    double remain = rect_area - best_used_area;
    long long ans = llround(remain); // 四舍五入
    cout << ans << "\n";

    return 0;
}
